// ============================================
// 17 - 智能指针 (Smart Pointers)
// ============================================

/// 智能指针是拥有额外元数据和功能的数据结构

use std::rc::Rc;
use std::cell::RefCell;
use std::ops::Deref;

// ==================== Box<T> ====================

/// Box<T> - 在堆上分配数据
pub fn box_basics() {
    println!("\n=== Box<T> 基础 ===");
    
    // 在堆上存储数据
    let b = Box::new(5);
    println!("堆上的值: {}", b);
    
    // Box 的使用场景
    println!("\n使用场景:");
    println!("1. 编译时大小未知的类型");
    println!("2. 大量数据所有权转移时避免拷贝");
    println!("3. 拥有实现特定 trait 的类型值");
}

/// 递归类型
#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),
    Nil,
}

pub fn recursive_types() {
    println!("\n=== 递归类型 ===");
    
    use List::{Cons, Nil};
    
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
    println!("链表: {:?}", list);
}

// ==================== Deref Trait ====================

/// Deref trait
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

impl<T> Deref for MyBox<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub fn deref_trait() {
    println!("\n=== Deref Trait ===");
    
    let x = 5;
    let y = MyBox::new(x);
    
    assert_eq!(5, x);
    assert_eq!(5, *y); // 解引用
    
    println!("解引用成功");
}

/// 隐式 Deref 强制转换
fn hello(name: &str) {
    println!("你好, {}!", name);
}

pub fn deref_coercion() {
    println!("\n=== 隐式 Deref 强制转换 ===");
    
    let m = MyBox::new(String::from("Rust"));
    hello(&m); // &MyBox<String> -> &String -> &str
    
    println!("Deref 强制转换自动处理");
}

// ==================== Drop Trait ====================

/// Drop trait
struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("释放 CustomSmartPointer: `{}`!", self.data);
    }
}

pub fn drop_trait() {
    println!("\n=== Drop Trait ===");
    
    {
        let _c = CustomSmartPointer {
            data: String::from("数据1"),
        };
        let _d = CustomSmartPointer {
            data: String::from("数据2"),
        };
        println!("创建了 CustomSmartPointer");
    } // drop 在这里自动调用
    
    println!("CustomSmartPointer 已离开作用域");
}

/// 提前 drop
pub fn early_drop() {
    println!("\n=== 提前 Drop ===");
    
    let c = CustomSmartPointer {
        data: String::from("提前释放"),
    };
    println!("创建了 CustomSmartPointer");
    drop(c); // 手动调用 drop
    println!("提前释放完成");
}

// ==================== Rc<T> ====================

/// Rc<T> - 引用计数智能指针
pub fn rc_basics() {
    println!("\n=== Rc<T> 基础 ===");
    
    #[derive(Debug)]
    enum List2 {
        Cons(i32, Rc<List2>),
        Nil,
    }
    
    use List2::{Cons, Nil};
    
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("创建 a, 引用计数 = {}", Rc::strong_count(&a));
    
    let _b = Cons(3, Rc::clone(&a));
    println!("创建 b, 引用计数 = {}", Rc::strong_count(&a));
    
    {
        let _c = Cons(4, Rc::clone(&a));
        println!("创建 c, 引用计数 = {}", Rc::strong_count(&a));
    }
    
    println!("c 离开作用域, 引用计数 = {}", Rc::strong_count(&a));
}

/// Rc<T> 使用场景
pub fn rc_use_cases() {
    println!("\n=== Rc<T> 使用场景 ===");
    
    println!("1. 在堆上分配数据供多个所有者使用");
    println!("2. 图数据结构");
    println!("3. 共享只读数据");
    println!("注意: Rc<T> 只能用于单线程场景");
}

// ==================== RefCell<T> ====================

/// RefCell<T> - 内部可变性
pub fn refcell_basics() {
    println!("\n=== RefCell<T> 基础 ===");
    
    let x = RefCell::new(5);
    println!("初始值: {:?}", x);
    
    // 可变借用
    *x.borrow_mut() += 1;
    println!("修改后: {:?}", x);
    
    // 不可变借用
    println!("当前值: {}", *x.borrow());
}

/// 内部可变性模式
pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct MockMessenger {
    sent_messages: RefCell<Vec<String>>,
}

impl MockMessenger {
    pub fn new() -> MockMessenger {
        MockMessenger {
            sent_messages: RefCell::new(vec![]),
        }
    }
}

impl Messenger for MockMessenger {
    fn send(&self, message: &str) {
        self.sent_messages.borrow_mut().push(String::from(message));
    }
}

pub fn interior_mutability() {
    println!("\n=== 内部可变性 ===");
    
    let messenger = MockMessenger::new();
    messenger.send("消息1");
    messenger.send("消息2");
    
    println!("发送的消息数: {}", messenger.sent_messages.borrow().len());
}

// ==================== Rc<RefCell<T>> ====================

/// 结合 Rc<T> 和 RefCell<T>
pub fn rc_refcell() {
    println!("\n=== Rc<RefCell<T>> ===");
    
    #[derive(Debug)]
    enum List3 {
        Cons(Rc<RefCell<i32>>, Rc<List3>),
        Nil,
    }
    
    use List3::{Cons, Nil};
    
    let value = Rc::new(RefCell::new(5));
    
    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
    let _b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let _c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
    
    *value.borrow_mut() += 10;
    
    println!("修改后 a = {:?}", a);
}

// ==================== Weak<T> ====================

/// Weak<T> - 弱引用
pub fn weak_references() {
    println!("\n=== Weak<T> ===");
    
    use std::rc::Weak;
    
    #[derive(Debug)]
    struct Node {
        value: i32,
        parent: RefCell<Weak<Node>>,
        children: RefCell<Vec<Rc<Node>>>,
    }
    
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });
    
    println!("leaf 强引用 = {}, 弱引用 = {}", 
             Rc::strong_count(&leaf), Rc::weak_count(&leaf));
    
    {
        let branch = Rc::new(Node {
            value: 5,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![Rc::clone(&leaf)]),
        });
        
        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
        
        println!("branch 强引用 = {}, 弱引用 = {}",
                 Rc::strong_count(&branch), Rc::weak_count(&branch));
        println!("leaf 强引用 = {}, 弱引用 = {}",
                 Rc::strong_count(&leaf), Rc::weak_count(&leaf));
    }
    
    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
    println!("leaf 强引用 = {}, 弱引用 = {}",
             Rc::strong_count(&leaf), Rc::weak_count(&leaf));
}

// ==================== Arc<T> ====================

/// Arc<T> - 原子引用计数（用于多线程）
pub fn arc_basics() {
    println!("\n=== Arc<T> ===");
    
    println!("Arc<T> 是 Rc<T> 的线程安全版本");
    println!("使用原子操作保证线程安全");
    println!("性能略低于 Rc<T>");
}

// ==================== Cell<T> ====================

/// Cell<T>
pub fn cell_basics() {
    println!("\n=== Cell<T> ===");
    
    use std::cell::Cell;
    
    let c = Cell::new(5);
    println!("初始值: {}", c.get());
    
    c.set(10);
    println!("修改后: {}", c.get());
    
    println!("\nCell<T> vs RefCell<T>:");
    println!("- Cell<T>: 复制值，适用于实现 Copy 的类型");
    println!("- RefCell<T>: 借用值，适用于任何类型");
}

// ==================== 智能指针对比 ====================

/// 智能指针对比
pub fn smart_pointer_comparison() {
    println!("\n=== 智能指针对比 ===");
    
    println!("Box<T>:");
    println!("  - 单一所有者");
    println!("  - 编译时检查");
    println!("  - 堆分配");
    
    println!("\nRc<T>:");
    println!("  - 多个所有者");
    println!("  - 运行时引用计数");
    println!("  - 不可变共享");
    println!("  - 单线程");
    
    println!("\nArc<T>:");
    println!("  - 多个所有者");
    println!("  - 原子引用计数");
    println!("  - 线程安全");
    
    println!("\nRefCell<T>:");
    println!("  - 内部可变性");
    println!("  - 运行时借用检查");
    println!("  - 单线程");
    
    println!("\nCell<T>:");
    println!("  - 内部可变性");
    println!("  - 复制值");
    println!("  - 适用于 Copy 类型");
}

// ==================== 循环引用 ====================

/// 循环引用问题
pub fn reference_cycles() {
    println!("\n=== 循环引用 ===");
    
    println!("循环引用可能导致内存泄漏");
    println!("使用 Weak<T> 打破循环");
    println!("Weak<T> 不增加强引用计数");
}

// ==================== 最佳实践 ====================

/// 智能指针最佳实践
pub fn best_practices() {
    println!("\n=== 最佳实践 ===");
    
    println!("1. 默认使用 Box<T>");
    println!("2. 需要多个所有者时使用 Rc<T>");
    println!("3. 多线程环境使用 Arc<T>");
    println!("4. 内部可变性使用 RefCell<T> 或 Cell<T>");
    println!("5. 避免循环引用，使用 Weak<T>");
    println!("6. 理解编译时 vs 运行时检查");
    println!("7. 注意 RefCell<T> 的运行时 panic");
}

/// 主函数 - 演示所有功能
#[allow(dead_code)]
pub fn main() {
    println!("╔════════════════════════════════════════╗");
    println!("║   Rust 智能指针教程                    ║");
    println!("╚════════════════════════════════════════╝");
    
    box_basics();
    recursive_types();
    deref_trait();
    deref_coercion();
    drop_trait();
    early_drop();
    rc_basics();
    rc_use_cases();
    refcell_basics();
    interior_mutability();
    rc_refcell();
    weak_references();
    arc_basics();
    cell_basics();
    smart_pointer_comparison();
    reference_cycles();
    best_practices();
    
    println!("\n✅ 智能指针教程完成！");
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_box() {
        let b = Box::new(5);
        assert_eq!(*b, 5);
    }
    
    #[test]
    fn test_rc() {
        let a = Rc::new(5);
        let b = Rc::clone(&a);
        assert_eq!(Rc::strong_count(&a), 2);
        drop(b);
        assert_eq!(Rc::strong_count(&a), 1);
    }
    
    #[test]
    fn test_refcell() {
        let x = RefCell::new(5);
        *x.borrow_mut() += 1;
        assert_eq!(*x.borrow(), 6);
    }
    
    #[test]
    fn test_mock_messenger() {
        let messenger = MockMessenger::new();
        messenger.send("test");
        assert_eq!(messenger.sent_messages.borrow().len(), 1);
    }
}

